const { query } = require('../lib/db');

/**
 * 查找数据
 * @param {Object} options - 查询选项
 * @param {number} options.id - 根据 ID 查询（可选）
 * @param {string} options.title - 根据标题查询（可选，支持模糊查询）
 * @param {number} options.limit - 限制返回数量（可选）
 * @param {number} options.offset - 偏移量（可选）
 * @returns {Promise<Array>} 查询结果
 */
async function findWords(options = {}) {
  try {
    let sql = 'SELECT * FROM word WHERE 1=1';
    const params = [];

    // 根据 ID 查询
    if (options.id) {
      sql += ' AND id = ?';
      params.push(options.id);
    }

    // 根据标题查询（模糊查询）
    if (options.title) {
      sql += ' AND title LIKE ?';
      params.push(`%${options.title}%`);
    }

    // 排序
    sql += ' ORDER BY created_at DESC';

    // 分页
    if (options.limit) {
      sql += ' LIMIT ?';
      params.push(options.limit);
      
      if (options.offset) {
        sql += ' OFFSET ?';
        params.push(options.offset);
      }
    }

    const result = await query(sql, params);
    return result;
  } catch (error) {
    console.error('查找数据失败:', error.message);
    throw error;
  }
}

/**
 * 根据 ID 查找单条数据
 * @param {number} id - 数据 ID
 * @returns {Promise<Object|null>} 查询结果
 */
async function findWordById(id) {
  try {
    const result = await query('SELECT * FROM word WHERE id = ?', [id]);
    return result.length > 0 ? result[0] : null;
  } catch (error) {
    console.error('查找数据失败:', error.message);
    throw error;
  }
}

/**
 * 新增数据
 * @param {Object} data - 要插入的数据
 * @param {string} data.title - 标题
 * @param {string} data.content - 内容
 * @param {string} data.material - 材料
 * @returns {Promise<Object>} 插入结果，包含插入的 ID
 */
async function createWord(data) {
  try {
    const { title, content, material } = data;
    
    if (!title) {
      throw new Error('标题不能为空');
    }

    const result = await query(
      'INSERT INTO word (title, content, material) VALUES (?, ?, ?)',
      [title, content || null, material || null]
    );

    // 返回插入的数据
    const insertedId = result.insertId;
    return await findWordById(insertedId);
  } catch (error) {
    console.error('新增数据失败:', error.message);
    throw error;
  }
}

/**
 * 更新数据
 * @param {number} id - 要更新的数据 ID
 * @param {Object} data - 要更新的数据
 * @param {string} data.title - 标题（可选）
 * @param {string} data.content - 内容（可选）
 * @param {string} data.material - 材料（可选）
 * @returns {Promise<Object|null>} 更新后的数据
 */
async function updateWord(id, data) {
  try {
    if (!id) {
      throw new Error('ID 不能为空');
    }

    // 检查数据是否存在
    const existing = await findWordById(id);
    if (!existing) {
      throw new Error('数据不存在');
    }

    // 构建更新字段
    const updates = [];
    const params = [];

    if (data.title !== undefined) {
      updates.push('title = ?');
      params.push(data.title);
    }

    if (data.content !== undefined) {
      updates.push('content = ?');
      params.push(data.content);
    }

    if (data.material !== undefined) {
      updates.push('material = ?');
      params.push(data.material);
    }

    if (updates.length === 0) {
      throw new Error('没有要更新的字段');
    }

    params.push(id);
    await query(
      `UPDATE word SET ${updates.join(', ')} WHERE id = ?`,
      params
    );

    // 返回更新后的数据
    return await findWordById(id);
  } catch (error) {
    console.error('更新数据失败:', error.message);
    throw error;
  }
}

/**
 * 删除数据
 * @param {number} id - 要删除的数据 ID
 * @returns {Promise<boolean>} 是否删除成功
 */
async function deleteWord(id) {
  try {
    if (!id) {
      throw new Error('ID 不能为空');
    }

    // 检查数据是否存在
    const existing = await findWordById(id);
    if (!existing) {
      throw new Error('数据不存在');
    }

    await query('DELETE FROM word WHERE id = ?', [id]);
    return true;
  } catch (error) {
    console.error('删除数据失败:', error.message);
    throw error;
  }
}

/**
 * 批量删除数据
 * @param {Array<number>} ids - 要删除的数据 ID 数组
 * @returns {Promise<number>} 删除的记录数
 */
async function deleteWords(ids) {
  try {
    if (!ids || ids.length === 0) {
      throw new Error('ID 数组不能为空');
    }

    const placeholders = ids.map(() => '?').join(',');
    const result = await query(
      `DELETE FROM word WHERE id IN (${placeholders})`,
      ids
    );

    return result.affectedRows;
  } catch (error) {
    console.error('批量删除数据失败:', error.message);
    throw error;
  }
}

module.exports = {
  findWords,
  findWordById,
  createWord,
  updateWord,
  deleteWord,
  deleteWords
};
